// 房间页面逻辑
const app = getApp()
const AvatarUtils = require('../../utils/avatarUtils')
const RoomCache = require('../../utils/roomCache.js')
const RoomUtils = require('../../utils/roomUtils.js')

Page({
  data: {
    roomCode: '',
    roomInfo: null,
    players: [],
    records: [],
    currentUser: null,
    loading: false,
    loadingRecords: false,
    hasJoinedRoom: false,
    realtimeMessages: [],
    showExpenseModal: false,
    selectedPlayer: null,
    expenseAmount: '',
    expenseType: 'score', // score, tea_meal
    keyboardHeight: 0, // 键盘高度
    modalOffset: 0, // 模态框偏移量
    showInviteModal: false,
    qrCodeData: null,
    settlementNotification: null, // 结算通知
    hasShownInviteModal: false, // 是否已显示过邀请弹窗
    // 房主相关
    isOwner: false,
    ownerInfo: {
      avatar: '',
      nickname: '',
      current_score: 0
    },
    ownerInfoLastUpdate: 0, // 房主信息最后更新时间戳
    showOwnerSettingsModal: false,
    tempNickname: '',
    voiceEnabled: true,
    // 茶饭设置
    showTeaMealModal: false,
    teaMealLimit: 0,
    teaMealPercentage: 10,
    teaMealMode: 'percentage', // percentage: 按比例, fixed: 固定分数
    teaMealFixedAmount: 0,
    // 刷新相关
    isRefreshing: false,
    lastRefreshTime: 0,
    userIsInteracting: false, // 用户是否正在交互
    // WebSocket相关
    websocketConnected: false,
    websocketReconnectAttempts: 0,
    maxReconnectAttempts: 5,
    // 分页相关数据
    currentPage: 1,
    hasMoreRecords: true,
    loadingMore: false,
    // 结算相关
    settlementLoading: false,
    // 茶饭记录相关
    teaMealRecords: [],
    currentTeaMealPage: 1,
    hasMoreTeaMealRecords: true,
    showTeaMealRecords: false
  },

  onLoad(options = {}) {
    // 重置所有相关状态，确保重新进入新房间时能重新加载所有数据
    console.log('页面加载，重置所有状态，准备加载新房间数据:', options.roomCode || '无房间代码')
    this.setData({
      realtimeMessages: [], // 完全清空，避免不同房间数据混合
      hasJoinedRoom: false,
      records: [],
      currentPage: 1,
      hasMoreRecords: true,
      settlementNotification: null // 清空结算通知
    })
    
    // 读取语音播报设置
    const voiceEnabled = wx.getStorageSync('voiceEnabled')
    if (voiceEnabled !== undefined) {
      this.setData({ voiceEnabled })
    }
    
    // 优先级：1. URL参数中的roomCode 2. 待处理的pending_room_code（从分享链接进入）
    let roomCode = options.roomCode
    if (!roomCode) {
      // 检查是否有待处理的房间代码（从分享链接或扫码进入）
      const pendingRoomCode = wx.getStorageSync('pending_room_code')
      if (pendingRoomCode) {
        console.log('从待处理房间代码获取:', pendingRoomCode)
        roomCode = pendingRoomCode
        // 清除待处理的房间代码，避免下次进入时重复使用
        wx.removeStorageSync('pending_room_code')
      }
    }
    
    // 如果有房间代码参数，优先使用参数（避免检查过早导致跳转）
    if (roomCode) {
      console.log('使用房间代码:', roomCode)
      this.setData({ roomCode: roomCode })
      
      // 检查登录状态，如果未登录，先引导登录
      const app = getApp()
      app.checkLoginStatus()
      
      if (!app.globalData.isLoggedIn || !app.globalData.userInfo) {
        console.log('用户未登录，需要先登录')
        // 先保存房间代码，登录成功后再处理
        wx.setStorageSync('pending_room_code', roomCode)
        
        // 跳转到登录页面
        wx.redirectTo({
          url: '/pages/auth/auth',
          success: () => {
            console.log('已跳转到登录页面')
          },
          fail: (err) => {
            console.error('跳转到登录页面失败:', err)
            wx.showToast({
              title: '请先登录',
              icon: 'none'
            })
            setTimeout(() => {
              wx.navigateBack()
            }, 1500)
          }
        })
        return
      }
      
      // 已登录，直接获取房间信息
      this.setData({ roomCode: roomCode }, () => {
        // 先获取房间信息
        this.getRoomInfo()
        // 强制从第1页获取最新记录
        this.getRoomRecords(1, false)
      })
    } else {
      // 没有参数时，检查缓存和房间状态
      const shouldContinue = this.checkRoomStatusImmediately()
      if (shouldContinue) {
        this.loadRoomFromCache()
      }
    }
  },

  onShow() {
    console.log('onShow调用，当前roomCode:', this.data.roomCode)
    
    // 检查登录状态（如果从登录页面返回，可能已登录）
    const app = getApp()
    app.checkLoginStatus()
    
    // 如果已登录且有房间代码但还没有房间信息，说明可能是登录后返回，需要重新加载
    if (app.globalData.isLoggedIn && app.globalData.userInfo && this.data.roomCode && !this.data.roomInfo) {
      console.log('登录后返回，重新加载房间信息')
      // 确保设置当前用户信息
      this.setData({ currentUser: app.globalData.userInfo })
      // 获取房间信息
      this.getRoomInfo()
      // 强制从第1页获取最新记录
      this.getRoomRecords(1, false)
      
      // 更新tabbar状态
      this.updateTabbarStatus()
      
      // 确保WebSocket连接
      this.ensureWebSocketConnection()
      
      // 如果房间信息和用户信息都存在，确保WebSocket连接已初始化
      if (this.data.roomInfo && this.data.currentUser) {
        // 检查WebSocket连接状态
        this.checkWebSocketStatus()
        
        // 重要：确保已发送 connect 消息（后端需要这个才能注册用户和订阅房间）
        const manager = app.getWebSocketManager()
        if (manager.isConnected()) {
          console.log('onShow: 检查并确保connect消息已发送...')
          manager.ensureConnectMessageSent()
        }
        
        this.initGlobalWebSocket()
        // 确保数据同步，特别是对于新加入的玩家
        this.ensureDataSync()
      }
      return
    }
    
    // 每次显示页面时都清空活动记录并重新加载，确保显示最新数据
    this.setData({
      realtimeMessages: [], // 清空活动记录
      records: [], // 清空历史记录
      currentPage: 1,
      hasMoreRecords: true
    })
    
    // 只在没有房间信息时才从缓存加载，避免重复请求
    if (!this.data.roomInfo || !this.data.roomCode) {
      this.loadRoomFromCache()
    } else {
      // 如果有房间信息，确保保存到本地存储
      this.saveCurrentRoomInfo()
      // 刷新房间信息以获取最新玩家列表
      this.getRoomInfo()
      // 强制刷新最新记录，避免使用过期缓存
      console.log('页面显示时强制刷新最新记录')
      this.getRoomRecords(1, false)
    }
    
    // 更新tabbar状态
    this.updateTabbarStatus()
    
    // 确保WebSocket连接
    this.ensureWebSocketConnection()
    
    // 如果房间信息和用户信息都存在，确保WebSocket连接已初始化
    if (this.data.roomInfo && this.data.currentUser) {
      // 检查WebSocket连接状态
      this.checkWebSocketStatus()
      this.initGlobalWebSocket()
      // 确保数据同步，特别是对于新加入的玩家
      this.ensureDataSync()
    }
  },

  // 处理头像URL，添加baseUrl前缀
  processAvatarUrl(avatar) {
    if (avatar && !avatar.startsWith('http') && !avatar.startsWith('/images/')) {
      return getApp().globalData.baseUrl + avatar
    }
    return avatar || '/images/default-avatar.png'
  },

  // 处理玩家列表的头像URL
  processPlayersAvatars(players) {
    return players.map(player => ({
      ...player,
      avatarUrl: this.processAvatarUrl(player.avatar)
    }))
  },

  onHide() {
    // 页面隐藏时停止定时刷新
    this.stopRoomRefresh()
    // ⚠️ 重要：onHide 时不要清理 WebSocket 订阅
    // 因为用户可能只是切换到其他 tab（比如首页、排行榜），还会回来
    // 清理订阅会导致后端发送 leave_room，清理 room 和 users 映射
    // 只有在页面真正卸载（onUnload）时才清理
    console.log('页面隐藏，保持 WebSocket 订阅（不清理）')
  },

  onUnload() {
    // 页面卸载时停止定时刷新
    this.stopRoomRefresh()
    // 取消全局WebSocket订阅
    this.cleanupGlobalWebSocket()
  },

  // 分享给好友
  async onShareAppMessage() {
    const ShareUtil = require('../../utils/shareUtil')
    return await ShareUtil.generateShareAppMessageConfig('room', {
      roomCode: this.data.roomCode,
      roomInfo: this.data.roomInfo
    })
  },

  // 分享到朋友圈
  async onShareTimeline() {
    const ShareUtil = require('../../utils/shareUtil')
    return await ShareUtil.generateShareTimelineConfig('room', {
      roomCode: this.data.roomCode,
      roomInfo: this.data.roomInfo
    })
  },

  // 从本地缓存加载房间信息
  loadRoomFromCache() {
    try {
      const RoomCache = require('../../utils/roomCache')
      const currentRoom = RoomCache.getRoom()
      
      if (currentRoom) {
        console.log('从缓存加载房间信息:', currentRoom)
        this.setData({
          roomCode: currentRoom.roomCode,
          roomInfo: currentRoom.roomInfo,
          players: currentRoom.roomInfo?.users || []
        }, () => {
          console.log('setData完成，当前roomCode:', this.data.roomCode)
          
          // 设置当前用户信息
          const userInfo = wx.getStorageSync('userInfo') || getApp().globalData.userInfo
          if (userInfo) {
            this.setData({ currentUser: userInfo })
            // 设置全局用户信息，确保WebSocket管理器能获取到
            getApp().globalData.userInfo = userInfo
            // 检查是否为房主
            this.checkIsOwner()
            // 从缓存加载时不添加进入房间记录，避免重复
            
            // 如果是房主，立即刷新房间信息以获取最新分数
            if (this.data.isOwner) {
              console.log('房主从缓存加载，立即刷新房间信息')
              this.getRoomInfo()
            }
          }
          
          // 如果是新创建的房间且未显示过邀请弹窗，显示邀请弹窗
          if (currentRoom.isNewRoom && !this.data.hasShownInviteModal) {
            setTimeout(() => {
              this.showInviteModal()
              // 标记已显示过邀请弹窗
              this.setData({ hasShownInviteModal: true })
            }, 1000)
          }
        })
      } else {
        // 没有有效的房间缓存，跳转到首页
        this.navigateToHomePage()
      }
    } catch (error) {
      console.error('读取房间缓存失败:', error)
      try {
        const RoomCache = require('../../utils/roomCache')
        RoomCache.clearRoom()
      } catch (e) {
        console.error('清除房间缓存失败:', e)
      }
      // 发生错误时跳转到首页
      this.navigateToHomePage()
    }
  },
  
  // 跳转到首页
  navigateToHomePage() {
    console.log('没有房间信息，跳转到首页')
    wx.showToast({
      title: '请创建或加入房间',
      icon: 'none',
      duration: 1500
    })
    setTimeout(() => {
      wx.navigateBack({
        delta: 1
      })
    }, 1500)
  },

  // 显示加入房间对话框
  showJoinRoomDialog() {
    wx.showModal({
      title: '加入房间',
      content: '请输入房间代码',
      editable: true,
      placeholderText: '例如：283397',
      success: (res) => {
        if (res.confirm && res.content) {
          const roomCode = res.content.trim()
          this.setData({ roomCode: roomCode })
          this.getRoomInfo()
          this.getRoomRecords()
        } else {
          // 用户取消，返回首页
          this.goToHome()
        }
      }
    })
  },

  // 返回首页
  goToHome() {
    wx.navigateBack({
      delta: 1
    })
  },

  // 获取房间信息
  getRoomInfo() {
    console.log('getRoomInfo调用，当前roomCode:', this.data.roomCode)
    if (!this.data.roomCode) {
      console.log('房间代码为空，尝试从缓存加载')
      // 尝试从缓存加载
      this.loadRoomFromCache()
      return
    }

    // 如果正在加载，避免重复请求
    if (this.data.loading) {
      console.log('正在加载中，跳过重复请求')
      return
    }

    // 检查是否距离上次刷新时间太短，避免过于频繁的请求
    const now = Date.now()
    if (now - this.data.lastRefreshTime < 2000) {
      console.log('距离上次刷新时间太短，跳过请求')
      return
    }

    this.setData({ 
      loading: true,
      lastRefreshTime: now
    })
    console.log('发送API请求，参数:', { room_code: this.data.roomCode })
    console.log('roomCode值:', this.data.roomCode)
    console.log('baseUrl值:', getApp().globalData.baseUrl)
    const requestUrl = `${getApp().globalData.baseUrl}/api/room/get-by-code?room_code=${this.data.roomCode}`
    console.log('完整URL:', requestUrl)
    console.log('实际发送的URL:', requestUrl)
    wx.request({
      url: requestUrl,
      method: 'GET',
      success: (res) => {
        console.log('房间信息响应:', res.data)
        if (res.data.success) {
          const roomData = res.data.data
          console.log('房间数据:', roomData)
          // 直接使用后端返回的已排序用户列表
          const sortedUsers = roomData.users || []
          
          console.log('设置玩家数据:', {
            players: sortedUsers,
            playersLength: sortedUsers.length,
            playersData: sortedUsers.map(p => ({
              id: p.id,
              nickname: p.nickname,
              avatar: p.avatar,
              current_score: p.current_score
            }))
          })
          
          console.log('当前用户信息:', this.data.currentUser)
          console.log('房间信息:', roomData)
          console.log('是否为房主:', this.data.currentUser?.id === roomData.created_by)
          
          // 确保有当前用户信息
          if (!this.data.currentUser) {
            const userInfo = wx.getStorageSync('userInfo') || getApp().globalData.userInfo
            if (userInfo) {
              this.setData({ currentUser: userInfo })
              getApp().globalData.userInfo = userInfo
            }
          }
          
          // 处理头像URL并更新玩家列表
          const processedPlayers = this.processPlayersAvatars(sortedUsers)
          
          this.setData({
            roomInfo: roomData,
            players: processedPlayers
          })
          
          console.log('getRoomInfo - 已更新玩家列表，数量:', processedPlayers.length)
          processedPlayers.forEach((player, index) => {
            console.log(`玩家 ${index + 1}: ID=${player.id}, 昵称=${player.nickname}, 分数=${player.current_score}`)
          })
          
          // 保存当前房间信息到全局和本地存储（用于 WebSocket 自动订阅）
          // 使用 RoomCache 统一保存格式
          const RoomCache = require('../../utils/roomCache')
          RoomCache.saveRoom(roomData, { isNewRoom: false })
          getApp().globalData.currentRoom = roomData
          
          // 重新检查房主身份
          this.checkIsOwner()
          
          // 初始化WebSocket连接（异步执行，不阻塞）
          // 注意：这里只负责页面级别的消息处理，连接本身由 app.js 统一管理
          if (this.data.currentUser) {
            this.initGlobalWebSocket().catch(err => {
              console.error('初始化WebSocket失败:', err)
            })
          }
          
          // 更新房主信息（如果是房主）
          console.log('检查房主信息同步:', {
            isOwner: this.data.isOwner,
            ownerInfo: this.data.ownerInfo,
            currentUser: this.data.currentUser,
            sortedUsers: sortedUsers.map(u => ({ id: u.id, nickname: u.nickname, score: u.current_score }))
          })
          
          if (this.data.isOwner && this.data.currentUser) {
            const currentUser = sortedUsers.find(p => p.id === this.data.currentUser.id)
            console.log('找到当前用户:', currentUser)
            console.log('服务器返回的房主分数:', currentUser?.current_score)
            console.log('当前房主信息:', this.data.ownerInfo)
            
            if (currentUser) {
              // 直接使用服务器数据更新房主信息
      const newOwnerInfo = {
        id: this.data.currentUser.id,
        avatar: currentUser.avatar || this.data.ownerInfo.avatar || '',
        avatarUrl: this.processAvatarUrl(currentUser.avatar || this.data.ownerInfo.avatar || ''),
        nickname: currentUser.nickname || this.data.ownerInfo.nickname || '房主',
        current_score: currentUser.current_score || 0
      }
              console.log('更新房主信息:', {
                old: this.data.ownerInfo,
                new: newOwnerInfo
              })
              
              this.setData({
                ownerInfo: newOwnerInfo,
                currentUser: {
                  ...this.data.currentUser,
                  current_score: currentUser.current_score
                }
              })
              console.log('房主分数已同步:', currentUser.current_score)
              console.log('同步后的房主信息:', this.data.ownerInfo)
            } else {
              console.log('未找到当前用户在玩家列表中')
            }
          } else {
            console.log('房主信息同步条件不满足:', {
              isOwner: this.data.isOwner,
              hasCurrentUser: !!this.data.currentUser
            })
          }
          
          console.log('设置后的数据:', this.data)
          // 设置导航栏标题
          wx.setNavigationBarTitle({
            title: `房间 ${roomData.room_code}`
          })
          // 加入房间
          this.joinRoom()
          // 初始化WebSocket连接
          this.initGlobalWebSocket()
          // 保存当前房间信息
          this.saveCurrentRoomInfo()
          // 确保数据同步，特别是用户列表
          this.ensureUserListSync()
          // 移除自动获取结算通知，结算应该由用户主动触发
        } else {
          wx.showToast({
            title: res.data.message || '房间不存在',
            icon: 'none'
          })
          setTimeout(() => {
            wx.navigateBack()
          }, 1500)
        }
      },
      fail: (err) => {
        console.error('获取房间信息失败:', err)
        wx.showToast({
          title: '网络错误，请重试',
          icon: 'none'
        })
        setTimeout(() => {
          wx.navigateBack()
        }, 1500)
      },
      complete: () => {
        this.setData({ loading: false })
      }
    })
  },

  // 加入房间（仅初始化时调用一次）
  joinRoom() {
    const userInfo = wx.getStorageSync('userInfo') || getApp().globalData.userInfo
    if (!userInfo) {
      wx.showToast({
        title: '请先登录',
        icon: 'none'
      })
      setTimeout(() => {
        wx.navigateBack()
      }, 1500)
      return
    }

    this.setData({ currentUser: userInfo })
    // 设置全局用户信息，确保WebSocket管理器能获取到
    getApp().globalData.userInfo = userInfo
    
    // 检查是否为房主
    this.checkIsOwner()
    
    // 检查用户是否已经在房间中
    const isUserInRoom = this.data.players.some(player => player.id === userInfo.id)
    if (isUserInRoom) {
      console.log('用户已在房间中，跳过加入房间请求')
      // 即使用户已在房间中，也要确保WebSocket连接和数据同步
      this.ensureDataSync()
      return
    }
    
    // 只有在真正加入房间时才添加进入房间记录
    console.log('用户首次加入房间，添加进入房间记录')

    // 如果已经尝试过加入房间，避免重复请求
    if (this.data.hasJoinedRoom) {
      console.log('已经尝试过加入房间，跳过重复请求')
      return
    }
    
    this.setData({ hasJoinedRoom: true })
    
    // 调用加入房间API
    wx.request({
      url: `${getApp().globalData.baseUrl}/api/room/join`,
      method: 'POST',
      data: {
        room_code: this.data.roomCode,
        user_id: userInfo.id
      },
      success: (res) => {
        console.log('加入房间响应:', res.data)
        if (res.data.success) {
          if (res.data.data.already_joined) {
            console.log('用户已在房间中')
          } else {
            console.log('加入房间成功')
            // 注意：进入房间消息通过WebSocket接收，不需要本地添加
          }
          
          // 如果响应中包含了用户列表，立即更新玩家列表（避免等待WebSocket消息）
          // 这是第一次更新，确保UI立即反映最新状态
          if (res.data.data && res.data.data.users && Array.isArray(res.data.data.users)) {
            console.log('从API响应中获取用户列表，立即更新:', res.data.data.users)
            const processedPlayers = this.processPlayersAvatars(res.data.data.users)
            const updateData = { players: processedPlayers }
            
            // 如果响应中包含了房间信息，同时更新房间信息（包括人数）
            if (res.data.data && res.data.data.room) {
              updateData.roomInfo = {
                ...this.data.roomInfo,
                ...res.data.data.room,
                current_players: res.data.data.room.current_players || res.data.data.users.length,
                max_players: res.data.data.room.max_players
              }
              console.log('从API响应中更新房间信息（人数）:', updateData.roomInfo.current_players, '/', updateData.roomInfo.max_players)
            }
            
            this.setData(updateData)
            
            // 更新房主信息
            this.updateOwnerInfoIfNeeded(res.data.data.users)
            
            // 更新当前用户分数（确保当前用户的分数是最新的）
            if (this.data.currentUser) {
              const updatedUser = res.data.data.users.find(u => u.id === this.data.currentUser.id)
              if (updatedUser) {
                console.log('从API响应中更新当前用户分数:', updatedUser.current_score)
                this.setData({
                  currentUser: {
                    ...this.data.currentUser,
                    current_score: updatedUser.current_score
                  }
                })
                // 更新缓存中的分数
                const RoomCache = require('../../utils/roomCache')
                RoomCache.saveScore(updatedUser.current_score)
              }
            }
          }
          
          // 保存当前房间信息到本地存储和全局
          this.saveCurrentRoomInfo()
          
          // 如果响应中包含了房间信息，立即保存到全局（用于 WebSocket 自动订阅）
          if (res.data.data && res.data.data.room) {
            const app = getApp()
            const room = res.data.data.room
            app.globalData.currentRoom = room
            
            // 使用 RoomCache 统一保存格式
            const RoomCache = require('../../utils/roomCache')
            RoomCache.saveRoom(room, { isNewRoom: false })
            
            // 确保 WebSocket 连接并订阅房间
            app.ensureWebSocketConnection().then(() => {
              // 连接建立后，主动触发刷新房间订阅（封装的可复用函数）
              // 解决时序问题：用户在连接建立后才加入房间的情况
              setTimeout(() => {
                app.refreshRoomSubscriptions()
              }, 300) // 延迟300ms，确保连接完全稳定
            }).catch(err => {
              console.error('加入房间后初始化WebSocket失败:', err)
            })
          } else {
            // 如果没有在响应中获取到房间信息，刷新房间信息（会在 getRoomInfo 成功回调中自动初始化 WebSocket）
            this.getRoomInfo()
          }
        } else {
          wx.showToast({
            title: res.data.message || '加入房间失败',
            icon: 'none'
          })
          setTimeout(() => {
            wx.navigateBack()
          }, 1500)
        }
      },
      fail: (err) => {
        console.error('加入房间失败:', err)
        wx.showToast({
          title: '网络错误，请重试',
          icon: 'none'
        })
      }
    })
  },

  // 获取房间记录（支持分页加载）
  getRoomRecords(page = 1, isLoadMore = false) {
    // 如果没有房间信息，不请求记录
    if (!this.data.roomInfo || !this.data.roomInfo.id) {
      console.log('房间信息不存在，跳过获取记录')
      return
    }

    // 如果正在加载记录，避免重复请求
    if (this.data.loadingRecords || (isLoadMore && this.data.loadingMore)) {
      console.log('正在加载记录中，跳过重复请求')
      return
    }

    // 设置加载状态
    const loadingData = {
      loadingRecords: true
    }
    if (isLoadMore) {
      loadingData.loadingMore = true
    }
    this.setData(loadingData)
    
    wx.request({
      url: `${getApp().globalData.baseUrl}/api/accounting/room-records`,
      method: 'GET',
      data: { 
        room_id: this.data.roomInfo.id,
        page: page,
        page_size: 20 // 每页20条记录
      },
      success: (res) => {
        if (res.data.success) {
          // 格式化记录时间，确保records是数组
          const safeRecords = Array.isArray(res.data.data.records) ? res.data.data.records : []
          
          // 如果数据库中没有记录，确保清空前端显示
          if (safeRecords.length === 0 && page === 1 && !isLoadMore) {
            // 完全清空活动记录和历史记录
            this.setData({
              records: [],
              realtimeMessages: [],
              hasMoreRecords: false,
              currentPage: 1
            })
            console.log('数据库中无记录，已清空前端显示')
            return
          }
          
          const newRecords = safeRecords.map(record => {
            if (record.created_at) {
              // 确保日期格式兼容iOS
              const formattedDate = record.created_at.replace(/^([\d]{4})-([\d]{2})-([\d]{2})\s/, '$1/$2/$3 ')
              const recordTime = new Date(formattedDate)
              record.created_at = `${recordTime.getHours().toString().padStart(2, '0')}:${recordTime.getMinutes().toString().padStart(2, '0')}`
            }
            return record
          })
          
          // 不再从历史记录生成实时消息，避免重复显示
          // 历史记录和实时消息应该分开处理
          
          // 简化处理：只更新历史记录，不处理实时消息
          let records = []
          
          if (isLoadMore && this.data.records) {
            // 加载更多模式：将新记录添加到现有记录后面
            records = [...this.data.records, ...newRecords]
          } else {
            // 初始化或刷新模式
            records = newRecords
          }
          
          // 只更新历史记录，保持实时消息不变
          this.setData({ 
            records,
            hasMoreRecords: res.data.data.has_more || newRecords.length === 20,
            currentPage: page
          })
          
          console.log('活动记录加载完成:', {
            recordsCount: records.length,
            isLoadMore: isLoadMore,
            currentPage: page,
            hasMore: res.data.data.has_more
          })
        }
      },
      fail: (err) => {
        console.error('获取房间记录失败:', err)
      },
      complete: () => {
        // 重置加载状态
        this.setData({ 
          loadingRecords: false,
          loadingMore: false
        })
      }
    })
  },

  // 茶饭
  teaMeal() {
    if (!this.data.currentUser) {
      wx.showToast({
        title: '请先登录',
        icon: 'none'
      })
      return
    }

    // 检查是否为房主
    if (this.data.isOwner) {
      // 房主可以设置茶饭规则
      this.setData({
        showTeaMealModal: true
      })
    } else {
      // 普通玩家可以选择给谁茶饭
      if (this.data.players.length <= 1) {
        wx.showToast({
          title: '房间人数不足',
          icon: 'none'
        })
        return
      }

      // 显示玩家选择弹框
      this.setData({
        showExpenseModal: true,
        expenseType: 'tea_meal'
      })
    }
  },


  // 显示分数输入
  showScoreInput(targetPlayer) {
    wx.showModal({
      title: `给 ${targetPlayer.nickname} 记分`,
      content: '请输入分数',
      editable: true,
      placeholderText: '10',
      success: (res) => {
        if (res.confirm && res.content) {
          const score = parseInt(res.content)
          if (!isNaN(score)) {
            this.doAddScore(targetPlayer.id, score)
          } else {
            wx.showToast({
              title: '请输入有效数字',
              icon: 'none'
            })
          }
        }
      }
    })
  },

  // 执行添加分数
  doAddScore(targetUserId, score) {
    wx.showLoading({ title: '记分中...' })
    wx.request({
      url: `${getApp().globalData.baseUrl}/api/accounting/add-record`,
      method: 'POST',
      data: {
        room_id: this.data.roomInfo.id,
        user_id: this.data.currentUser.id,
        target_user_id: targetUserId,
        score: score,
        description: ''
      },
      success: (res) => {
        if (res.data.success) {
          wx.showToast({
            title: '记分成功',
            icon: 'success'
          })
          // 刷新数据
          this.getRoomInfo()
          this.getRoomRecords()
        } else {
          wx.showToast({
            title: res.data.message || '记分失败',
            icon: 'none'
          })
        }
      },
      complete: () => {
        wx.hideLoading()
      }
    })
  },


  // 更新玩家列表
  updatePlayerList(user) {
    const players = [...this.data.players]
    const existingIndex = players.findIndex(p => p.id === user.id)
    if (existingIndex >= 0) {
      players[existingIndex] = user
    } else {
      players.push(user)
    }
    // 处理头像URL并设置数据
    const processedPlayers = this.processPlayersAvatars(players)
    this.setData({ players: processedPlayers })
  },

  // 移除玩家
  removePlayer(userId) {
    const players = this.data.players.filter(p => p.id !== userId)
    const processedPlayers = this.processPlayersAvatars(players)
    this.setData({ players: processedPlayers })
  },
  
  // 处理滚动到底部，加载更多历史记录
  onReachBottom() {
    // 如果正在加载中或没有更多记录，则不加载
    if (this.data.loadingMore || this.data.loadingRecords || !this.data.hasMoreRecords) {
      return
    }
    
    this.setData({ loadingMore: true })
    // 加载下一页历史记录
    const nextPage = this.data.currentPage + 1
    
    // 调用getRoomRecords加载更多历史记录
    this.getRoomRecords(nextPage, true)
  },

  // 更新玩家分数
  updatePlayerScore(record) {
    const players = this.data.players.map(player => {
      if (player.id === record.target_user_id) {
        return {
          ...player,
          current_score: (player.current_score || 0) + record.score
        }
      }
      return player
    })
    const processedPlayers = this.processPlayersAvatars(players)
    this.setData({ players: processedPlayers })
    
    // 添加记录到列表
    const records = [record, ...this.data.records]
    this.setData({ records })

    // 添加实时活动记录，确保支出操作在房间中清晰展示
    if (record && record.user && record.target_user) {
      const actionText = record.type === 'tea_meal' ? '茶饭' : '记分'
      const message = `${record.user.nickname} ${actionText}给 ${record.target_user.nickname} ${record.score > 0 ? '+' : ''}${record.score}`
      this.addRealtimeMessage(message, record.created_at)
    }
  },

  // 添加实时消息
  addRealtimeMessage(message, customTime = null) {
    // 防御性检查：确保消息内容有效
    if (!message || typeof message !== 'string') {
      console.warn('无效的消息内容:', message)
      return
    }
    
    let timeString
    let timestamp
    
    if (customTime) {
      // 使用提供的时间
      const messageTime = new Date(customTime)
      timeString = `${messageTime.getHours().toString().padStart(2, '0')}:${messageTime.getMinutes().toString().padStart(2, '0')}`
      timestamp = messageTime.getTime()
    } else {
      // 使用当前时间
      const now = new Date()
      timeString = `${now.getHours().toString().padStart(2, '0')}:${now.getMinutes().toString().padStart(2, '0')}`
      timestamp = now.getTime()
    }
    
    // 生成唯一ID，确保不同房间的消息不会冲突
    const roomId = this.data.roomInfo?.id || 'unknown'
    const messageId = `${roomId}-msg-${timestamp}-${Math.random().toString(36).substr(2, 9)}`
    
    const newMessage = {
      id: messageId,
      message: message,
      time: timeString,
      timestamp: timestamp,
      roomId: roomId
    }
    
    // 确保realtimeMessages已初始化
    const currentMessages = this.data.realtimeMessages || []
    
    // 创建消息集合用于去重，只处理当前房间的消息
    const messageSet = new Set()
    const filteredMessages = currentMessages.filter(msg => {
      // 只保留当前房间的消息
      if (msg.roomId && msg.roomId !== roomId) {
        return true // 保留其他房间的消息
      }
      
      const msgKey = msg.id || `${roomId}-${msg.message.substring(0, 50)}-${msg.timestamp || msg.time}`
      const isDuplicate = messageSet.has(msgKey)
      messageSet.add(msgKey)
      return !isDuplicate // 过滤掉重复消息
    })
    
    // 检查新消息是否重复
    const newMessageKey = `${roomId}-${message.substring(0, 50)}-${timestamp}`
    if (messageSet.has(newMessageKey)) {
      console.log('重复消息，跳过添加:', message)
      return
    }
    
    // 添加新消息
    const updatedMessages = [...filteredMessages, newMessage]
    
    // 只保留最新的10条消息
    const finalMessages = updatedMessages.slice(-10)
    
    this.setData({
      realtimeMessages: finalMessages
    })
    
    console.log('添加实时消息:', newMessage)
  },

  // 结算房间
  settleRoom() {
    const players = this.data.players.map(player => {
      return {
        id: player.id,
        nickname: player.nickname,
        score: player.current_score || 0
      }
    })
    this.settleRoomRequest(players)
  },

  // 处理结算请求
  settleRoomRequest(players) {
    wx.request({
      url: `${this.data.apiBaseUrl}/rooms/${this.data.roomInfo.id}/settle`,
      method: 'POST',
      data: {
        players: players
      },
      success: (res) => {
        if (res.data.success) {
          this.processSettlement(res.data.settlement)
        } else {
          wx.showToast({
            title: '结算失败',
            icon: 'none'
          })
        }
      },
      fail: () => {
        wx.showToast({
          title: '请求失败',
          icon: 'none'
        })
      }
    })
  },

  // 处理结算结果
  processSettlement(settlement) {
    const players = this.data.players.map(player => {
      return {
        id: player.id,
        nickname: player.nickname,
        score: player.current_score || 0
      }
    })
    this.setData({ players: players })
    this.setData({ records: [] })
    this.setData({ realtimeMessages: [] })
    this.setData({ loadingRecords: false })
    this.setData({ hasMoreRecords: false })
    this.setData({ currentPage: 1 })
    this.setData({ loadingMore: false })
    this.setData({ loadingSettlement: false })
    this.setData({ settlement: settlement })
    this.setData({ settlementVisible: true })
    this.setData({ settlementData: settlement.data.map(message => {
      return {
        message: message.message,
        time: message.time,
        data: message.settlement_data
      }
    }) })
    this.addRealtimeMessage("房间结算已完成，请查看结算详情")
  },

  // 显示支出弹窗
  showExpenseModal() {
    if (this.data.players.length <= 1) {
      wx.showToast({
        title: '房间人数不足',
        icon: 'none'
      })
      return
    }
    
    // 清空选择状态，让用户在弹窗中选择
    this.setData({ 
      showExpenseModal: true,
      selectedPlayer: null, // 不预选任何玩家
      userIsInteracting: true,
      keyboardHeight: 0,
      modalOffset: 0
    })
  },

  // 选择玩家
  selectPlayer(e) {
    const player = e.currentTarget.dataset.player
    console.log('选择玩家:', player)
    this.setData({ selectedPlayer: player })
  },

  // 点击玩家卡片选择支出对象
  selectPlayerForExpense(e) {
    const player = e.currentTarget.dataset.player
    console.log('选择玩家作为支出对象:', player)
    this.setData({ selectedPlayer: player })
  },

  // 处理玩家头像点击事件
  handlePlayerAvatarClick(e) {
    const player = e.currentTarget.dataset.player
    console.log('点击玩家头像:', player)
    
    // 检查是否点击的是自己的头像
    if (this.data.currentUser && player.id === this.data.currentUser.id) {
      // 如果是房主，显示房主设置弹窗
      if (this.data.isOwner) {
        this.showOwnerSettings()
      } else {
        // 如果不是房主，显示用户设置弹窗
        this.showUserSettings()
      }
      return
    }
    
    // 点击其他玩家头像，显示支出弹框
    this.showExpenseForPlayer(e)
  },

  // 点击好友头像显示支出弹框
  showExpenseForPlayer(e) {
    const player = e.currentTarget.dataset.player
    console.log('点击好友头像:', player)
    
    this.setData({
      showExpenseModal: true,
      selectedPlayer: player,
      expenseAmount: '',
      expenseType: 'score',
      userIsInteracting: true
    })
  },

  // 隐藏支出弹窗
  hideExpenseModal() {
    // 先收起键盘
    wx.hideKeyboard()
    this.setData({ 
      showExpenseModal: false,
      selectedPlayer: null,
      expenseAmount: '',
      expenseType: 'score',
      userIsInteracting: false,
      keyboardHeight: 0,
      modalOffset: 0
    })
  },

  // 阻止模态框背景滚动
  preventScroll(e) {
    // 阻止事件冒泡，防止背景滚动
    return false
  },

  // 选择玩家
  selectPlayer(e) {
    const player = e.currentTarget.dataset.player
    console.log('选择玩家:', player)
    this.setData({ selectedPlayer: player })
  },

  // 设置支出分数
  setExpenseAmount(e) {
    let value = e.detail.value
    
    // 过滤掉负数符号和无效字符
    if (value.includes('-')) {
      value = value.replace(/-/g, '')
    }
    
    // 只允许数字
    value = value.replace(/[^0-9]/g, '')
    
    this.setData({ expenseAmount: value })
  },

  // 输入框获得焦点
  onInputFocus(e) {
    console.log('输入框获得焦点', e.detail)
    // 监听键盘高度变化
    wx.onKeyboardHeightChange((res) => {
      console.log('键盘高度变化:', res.height)
      const keyboardHeight = res.height
      if (keyboardHeight > 0) {
        // 计算模态框应该上移的距离（键盘高度的一半 + 安全边距）
        // 注意：rpx 单位需要除以2转换为px，但这里我们直接用px
        const safeMargin = 50 // 安全边距（px）
        const modalOffset = -(keyboardHeight / 2 + safeMargin)
        this.setData({
          keyboardHeight: keyboardHeight,
          modalOffset: modalOffset
        })
      } else {
        // 键盘收起，恢复位置
        this.setData({
          keyboardHeight: 0,
          modalOffset: 0
        })
      }
    })
  },

  // 输入框失去焦点
  onInputBlur(e) {
    console.log('输入框失去焦点')
    // 延迟恢复位置，避免闪烁
    setTimeout(() => {
      this.setData({
        keyboardHeight: 0,
        modalOffset: 0
      })
    }, 200)
  },

  // 设置支出类型
  setExpenseType(e) {
    const type = e.currentTarget.dataset.type
    this.setData({ expenseType: type })
    
    // 如果是茶饭费，直接显示茶饭输入
    if (type === 'tea_meal' && this.data.selectedPlayer) {
      this.showTeaMealInput(this.data.selectedPlayer)
      this.setData({
        showExpenseModal: false
      })
    }
  },

  // 确认支出
  confirmExpense() {
    if (!this.data.selectedPlayer) {
      wx.showToast({
        title: '请选择玩家',
        icon: 'none'
      })
      return
    }

    if (!this.data.expenseAmount || isNaN(this.data.expenseAmount)) {
      wx.showToast({
        title: '请输入有效分数',
        icon: 'none'
      })
      return
    }

    const amount = parseInt(this.data.expenseAmount)
    if (amount === 0) {
      wx.showToast({
        title: '分数不能为0',
        icon: 'none'
      })
      return
    }

    if (amount < 0) {
      wx.showToast({
        title: '支出分数不能为负数',
        icon: 'none'
      })
      return
    }

    // 执行支出，通过WebSocket传递实时消息
    this.doExpense(this.data.selectedPlayer.id, amount, this.data.expenseType)
  },

  // 执行支出
  doExpense(targetUserId, amount, type) {
    wx.showLoading({ title: '处理中...' })
    wx.request({
      url: `${getApp().globalData.baseUrl}/api/accounting/add-record`,
      method: 'POST',
      data: {
        room_id: this.data.roomInfo.id,
        user_id: this.data.currentUser.id,
        target_user_id: targetUserId,
        score: amount,
        description: type === 'tea_meal' ? '茶饭费' : '',
        type: type
      },
      success: (res) => {
        if (res.data.success) {
          wx.showToast({
            title: '支出成功',
            icon: 'success',
            duration: 2000
          })
          this.hideExpenseModal()
          
          // 注意：WebSocket消息由后端API自动发送，前端不需要手动发送
          
          // 刷新数据
          this.getRoomInfo()
          // 重新从第一页获取记录，确保显示最新的记录
          this.getRoomRecords(1, false)
          
          // 更新当前用户分数到缓存
          this.updateCurrentUserScoreInCache()
          
          // 如果是房主，延迟刷新以确保数据一致性
          if (this.data.isOwner) {
            console.log('支出成功后延迟刷新房主信息')
            setTimeout(() => {
              this.getRoomInfo() // 重新获取房间信息
            }, 1000) // 延迟1秒确保服务器数据已更新
          }
          
          // 新增：通知个人中心页面更新分数
          this.notifyProfilePageUpdate()
        } else {
          wx.showToast({
            title: res.data.message || '支出失败',
            icon: 'none',
            duration: 2000
          })
        }
      },
      fail: (err) => {
        console.error('支出请求失败:', err)
        wx.showToast({
          title: '网络错误，请重试',
          icon: 'none',
          duration: 2000
        })
      },
      complete: () => {
        wx.hideLoading()
      }
    })
  },

  // 离开房间
  leaveRoom() {
    wx.showModal({
      title: '确认离开',
      content: '确定要离开房间吗？',
      success: (res) => {
        if (res.confirm) {
          // 注意：离开房间消息通过WebSocket接收，不需要本地添加
          
          // 使用统一的缓存管理清除房间缓存
          const RoomCache = require('../../utils/roomCache')
          RoomCache.clearRoom()
          
          // 清除页面数据
          this.setData({
            roomCode: '',
            roomInfo: null,
            players: [],
            records: [],
            // 注意：不清除realtimeMessages，保持活动记录
            hasJoinedRoom: false // 重置加入房间状态
          })
          // 返回首页
          wx.redirectTo({
            url: '/pages/index/index'
          })
        }
      }
    })
  },

  // 分享房间
  shareRoom() {
    // 调起微信分享
    wx.showShareMenu({
      withShareTicket: true,
      menus: ['shareAppMessage', 'shareTimeline']
    })
  },




  // 显示邀请弹窗
  showInviteModal() {
    this.setData({ 
      showInviteModal: true,
      hasShownInviteModal: true // 标记已显示过邀请弹窗
    })
    // 生成二维码
    this.generateQRCode()
    // 清除新房间标记，避免重复弹出
    const RoomCache = require('../../utils/roomCache')
    RoomCache.clearNewRoomFlag()
  },

  // 隐藏邀请弹窗
  hideInviteModal() {
    this.setData({ 
      showInviteModal: false,
      qrCodeData: null
    })
  },

  // 页面加载时预加载小程序码


  // 预加载统一小程序码
  preloadUniversalQRCode() {
    // 先检查缓存中是否已有有效的小程序码
    const cachedQRCode = RoomCache.getUniversalQRCode();
    if (!cachedQRCode) {
      // 缓存不存在或已过期，立即请求新的小程序码
      this.fetchAndCacheUniversalQRCode();
    }
  },

  // 获取并缓存统一小程序码
  fetchAndCacheUniversalQRCode() {
    wx.request({
      url: `${getApp().globalData.baseUrl}/api/room/universal-qrcode`,
      method: 'GET',
      success: (res) => {
        if (res.data.success) {
          // 创建符合缓存要求的数据结构
          const qrCodeData = {
            qrcode: {
              url: res.data.data.content?.content || '',
              content: 'pages/splash/splash'
            }
          }
          // 保存到缓存
          RoomCache.saveUniversalQRCode(qrCodeData.qrcode);
          console.log('小程序码已缓存');
        }
      },
      fail: (err) => {
        console.error('预加载小程序码失败:', err);
      }
    })
  },

  // 生成统一分享小程序码（现在优先使用缓存）
  generateQRCode() {
    console.log('获取统一小程序码');
    
    // 优先从缓存获取小程序码
    const cachedQRCode = RoomCache.getUniversalQRCode();
    
    if (cachedQRCode) {
      // 使用缓存数据立即显示小程序码
      const qrCodeData = {
        qrcode: cachedQRCode
      };
      
      this.setData({
        qrCodeData: qrCodeData
      });
      console.log('使用缓存的小程序码');
      
      // 同时在后台更新缓存（异步，不影响用户体验）
      this.fetchAndCacheUniversalQRCode();
    } else {
      // 缓存不存在，直接请求并显示
      wx.request({
        url: `${getApp().globalData.baseUrl}/api/room/universal-qrcode`,
        method: 'GET',
        success: (res) => {
          if (res.data.success) {
            // 正确处理返回的数据结构
            console.log('小程序码API返回数据:', res.data.data);
            
            // 创建符合页面显示要求的数据结构
            const qrCodeData = {
              qrcode: {
                // 直接使用base64数据作为图片URL
                url: res.data.data.content?.content || '',
                content: 'pages/splash/splash'
              }
            };
            
            this.setData({
              qrCodeData: qrCodeData
            });
            console.log('小程序码数据设置成功:', qrCodeData);
            
            // 保存到缓存
            RoomCache.saveUniversalQRCode(qrCodeData.qrcode);
          } else {
            wx.showToast({
              title: '获取小程序码失败',
              icon: 'error'
            });
          }
        },
        fail: (err) => {
          console.error('获取小程序码失败:', err);
          wx.showToast({
            title: '网络错误',
            icon: 'error'
          });
        }
      });
    }
  },

  // 复制房间代码
  copyRoomCode() {
    wx.setClipboardData({
      data: this.data.roomInfo.room_code,
      success: () => {
        wx.showToast({
          title: '房间代码已复制',
          icon: 'success'
        })
      }
    })
  },
  


  // 显示房主设置弹窗
  showOwnerSettings() {
    if (!this.data.isOwner) {
      return
    }
    
    this.setData({
      showOwnerSettingsModal: true,
      tempNickname: this.data.ownerInfo.nickname || ''
    })
  },

  // 显示用户设置弹窗
  showUserSettings() {
    this.setData({
      showOwnerSettingsModal: true,
      tempNickname: this.data.currentUser.nickname || ''
    })
  },

  // 隐藏房主设置弹窗
  hideOwnerSettings() {
    this.setData({
      showOwnerSettingsModal: false
    })
  },

  // 选择头像 - 使用头像工具类
  chooseAvatar() {
    AvatarUtils.showAvatarChooseModal(
      (avatarPath) => {
        // 头像选择成功，更新显示
        if (this.data.isOwner) {
          this.setData({
            'ownerInfo.avatar': avatarPath,
            'ownerInfo.avatarUrl': this.processAvatarUrl(avatarPath)
          })
        } else {
          this.setData({
            'currentUser.avatar': avatarPath,
            'currentUser.avatarUrl': this.processAvatarUrl(avatarPath)
          })
        }
      },
      (err) => {
        AvatarUtils.showError('选择头像失败')
      }
    )
  },

  // 昵称输入
  onNicknameInput(e) {
    this.setData({
      tempNickname: e.detail.value
    })
  },

  // 保存房主设置
  saveOwnerSettings() {
    const { tempNickname, ownerInfo, currentUser, voiceEnabled, isOwner } = this.data
    
    if (!tempNickname.trim()) {
      wx.showToast({
        title: '请输入昵称',
        icon: 'none'
      })
      return
    }

    if (isOwner) {
      // 更新房主信息
      const newOwnerInfo = {
        ...ownerInfo,
        nickname: tempNickname.trim()
      }
      
      this.setData({
        ownerInfo: newOwnerInfo,
        showOwnerSettingsModal: false
      })

      // 同步更新玩家列表中的房主信息
      const players = this.data.players.map(player => {
        if (player.id === this.data.currentUser.id) {
          return {
            ...player,
            nickname: tempNickname.trim(),
            avatar: newOwnerInfo.avatar
          }
        }
        return player
      })
      
      this.setData({ players })

      // 调用API更新用户信息
      this.updateUserInfo(newOwnerInfo)
    } else {
      // 更新当前用户信息
      const newCurrentUser = {
        ...currentUser,
        nickname: tempNickname.trim()
      }
      
      this.setData({
        currentUser: newCurrentUser,
        showOwnerSettingsModal: false
      })

      // 同步更新玩家列表中的用户信息
      const players = this.data.players.map(player => {
        if (player.id === this.data.currentUser.id) {
          return {
            ...player,
            nickname: tempNickname.trim(),
            avatar: newCurrentUser.avatar
          }
        }
        return player
      })
      
      this.setData({ players })
      
      // 更新全局用户信息
      getApp().globalData.userInfo = newCurrentUser
      wx.setStorageSync('userInfo', newCurrentUser)

      // 调用API更新用户信息
      this.updateUserInfo(newCurrentUser)
    }

    // 保存语音播报设置
    wx.setStorageSync('voiceEnabled', voiceEnabled)

    wx.showToast({
      title: '设置已保存',
      icon: 'success'
    })
  },

  // 手动结算房间
  manualSettlement() {
    const { roomCode, settlementLoading } = this.data
    
    if (settlementLoading) {
      return
    }

    wx.showModal({
      title: '确认结算',
      content: '确定要手动结算当前房间吗？结算后将无法继续记账。',
      success: (res) => {
        if (res.confirm) {
          this.performSettlement()
        }
      }
    })
  },

  // 执行结算
  performSettlement() {
    const { roomCode } = this.data
    
    this.setData({ settlementLoading: true })
    
    wx.request({
      url: `${app.globalData.baseUrl}/api/accounting/room-settlement-and-notify`,
      method: 'POST',
      data: {
        room_id: this.data.roomInfo.id,
        user_id: this.data.currentUser.id
      },
      success: (res) => {
        if (res.data.success) {
          // 使用工具函数处理结算响应
          RoomUtils.handleSettlementResponse(res.data, this.data.roomInfo.id)
        } else {
          wx.showToast({
            title: res.data.message || '结算失败',
            icon: 'none'
          })
        }
      },
      fail: (err) => {
        console.error('结算请求失败:', err)
        wx.showToast({
          title: '网络错误，请重试',
          icon: 'none'
        })
      },
      complete: () => {
        this.setData({ settlementLoading: false })
      }
    })
  },

  // 语音播报开关变化
  onVoiceSwitchChange(e) {
    const voiceEnabled = e.detail.value
    this.setData({ voiceEnabled })
    
    // 立即保存语音设置
    wx.setStorageSync('voiceEnabled', voiceEnabled)
    
    wx.showToast({
      title: voiceEnabled ? '语音播报已开启' : '语音播报已关闭',
      icon: 'none'
    })
  },

  // 更新用户信息到服务器
  updateUserInfo(ownerInfo) {
    wx.request({
      url: `${app.globalData.baseUrl}/api/user/update-room-info`,
      method: 'POST',
      data: {
        user_id: this.data.currentUser.id,
        room_id: this.data.roomInfo.id,
        nickname: ownerInfo.nickname,
        avatar: ownerInfo.avatar
      },
      success: (res) => {
        if (res.data.success) {
          console.log('房主信息更新成功')
        }
      },
      fail: (err) => {
        console.error('更新房主信息失败:', err)
      }
    })
  },

  // 立即检查房间状态
  checkRoomStatusImmediately() {
    console.log('立即检查房间状态')
    
    // 优先级：1. 页面URL参数 2. 待处理的pending_room_code 3. 缓存中的房间信息
    let roomCode = null
    
    // 从 getCurrentPages 获取 URL 参数
    const pages = getCurrentPages()
    const currentPage = pages[pages.length - 1]
    if (currentPage && currentPage.options && currentPage.options.roomCode) {
      roomCode = currentPage.options.roomCode
      console.log('从页面参数获取房间代码:', roomCode)
    } else {
      // 检查是否有待处理的房间代码（从分享链接或扫码进入）
      const pendingRoomCode = wx.getStorageSync('pending_room_code')
      if (pendingRoomCode) {
        console.log('从待处理房间代码获取:', pendingRoomCode)
        roomCode = pendingRoomCode
        // 清除待处理的房间代码
        wx.removeStorageSync('pending_room_code')
      }
    }
    
    if (roomCode) {
      if (!this.data.roomCode) {
        this.setData({ roomCode: roomCode })
      }
      return true // 有房间代码，不检查缓存
    }
    
    // 如果有 roomCode，不检查缓存（优先使用 URL 参数）
    if (this.data.roomCode) {
      console.log('已有 roomCode，跳过缓存检查')
      return true
    }
    
    // 检查用户是否在房间中（使用 RoomCache 工具类统一管理）
    const RoomCache = require('../../utils/roomCache')
    const currentRoom = RoomCache.getRoom()
    console.log('当前房间缓存:', currentRoom)
    
    // 检查房间缓存是否存在且有效
    if (!currentRoom) {
      console.log('用户未在房间中，立即跳转')
      wx.showToast({
        title: '请创建或加入房间',
        icon: 'none',
        duration: 1500
      })
      
      // 立即跳转到首页
      setTimeout(() => {
        wx.navigateBack({
          delta: 1
        })
      }, 1500)
      
      return false
    }
    
    // 如果有缓存，设置 roomCode
    if (currentRoom.roomCode) {
      this.setData({ roomCode: currentRoom.roomCode })
    }
    
    // 检查房间信息是否完整
    if (!currentRoom.roomInfo || !currentRoom.roomInfo.id || !currentRoom.roomInfo.room_code) {
      console.log('房间信息不完整，清除缓存并跳转')
      const RoomCache = require('../../utils/roomCache')
      RoomCache.clearRoom()
      
      wx.showToast({
        title: '房间信息异常，请重新加入',
        icon: 'none',
        duration: 1500
      })
      
      setTimeout(() => {
        wx.navigateBack({
          delta: 1
        })
      }, 1500)
      
      return false
    }
    
            // 检查房间是否已结算
            if (RoomUtils.isRoomSettled(currentRoom.roomInfo)) {
                console.log('房间已结算，清除缓存并跳转')
                RoomUtils.handleSettledRoom()
                return false
            }
    
    console.log('用户已在房间中，允许访问')
    return true
  },

  // 隐藏茶饭设置弹框
  hideTeaMealModal() {
    this.setData({
      showTeaMealModal: false
    })
  },

  // 茶饭上限输入
  onTeaMealLimitInput(e) {
    this.setData({
      teaMealLimit: parseInt(e.detail.value) || 0
    })
  },

  // 茶饭百分比变化
  onTeaMealPercentageChange(e) {
    this.setData({
      teaMealPercentage: e.detail.value
    })
  },

  // 设置茶饭费模式
  setTeaMealMode(e) {
    const mode = e.currentTarget.dataset.mode
    this.setData({
      teaMealMode: mode
    })
  },

  // 固定茶饭费输入
  onTeaMealFixedAmountInput(e) {
    this.setData({
      teaMealFixedAmount: parseInt(e.detail.value) || 0
    })
  },

  // 确认茶饭设置
  confirmTeaMealSettings() {
    const { teaMealLimit, teaMealPercentage, teaMealMode, teaMealFixedAmount } = this.data
    
    if (teaMealLimit <= 0) {
      wx.showToast({
        title: '请输入有效的上限分数',
        icon: 'none'
      })
      return
    }

    // 根据模式验证不同的参数
    if (teaMealMode === 'percentage' && teaMealPercentage <= 0) {
      wx.showToast({
        title: '请输入有效的扣除比例',
        icon: 'none'
      })
      return
    }

    if (teaMealMode === 'fixed' && teaMealFixedAmount <= 0) {
      wx.showToast({
        title: '请输入有效的固定分数',
        icon: 'none'
      })
      return
    }

    // 发送茶饭设置到服务器
    wx.request({
      url: `${getApp().globalData.baseUrl}/api/room/set-tea-meal`,
      method: 'POST',
      data: {
        room_id: this.data.roomInfo.id,
        user_id: this.data.currentUser.id,
        tea_meal_limit: teaMealLimit,
        tea_meal_percentage: teaMealPercentage,
        tea_meal_mode: teaMealMode,
        tea_meal_fixed_amount: teaMealFixedAmount
      },
      success: (res) => {
        if (res.data.success) {
          // 保存茶饭设置到本地
          wx.setStorageSync('teaMealSettings', {
            limit: teaMealLimit,
            percentage: teaMealPercentage
          })

          // 隐藏弹框
          this.setData({
            showTeaMealModal: false
          })

          wx.showToast({
            title: '茶饭设置已保存',
            icon: 'success'
          })

          // 添加实时消息
          let message = ''
          if (teaMealMode === 'percentage') {
            message = `房主设置了茶饭上限 ${teaMealLimit} 分，扣除比例 ${teaMealPercentage}%`
          } else {
            message = `房主设置了茶饭上限 ${teaMealLimit} 分，固定茶饭费 ${teaMealFixedAmount} 分`
          }
          this.addRealtimeMessage(message, new Date().toISOString())
        } else {
          wx.showToast({
            title: res.data.message || '茶饭设置失败',
            icon: 'none'
          })
        }
      },
      fail: (err) => {
        console.error('茶饭设置请求失败:', err)
        wx.showToast({
          title: '网络错误，请重试',
          icon: 'none'
        })
      }
    })
  },

  // 显示茶饭输入
  showTeaMealInput(targetPlayer) {
    wx.showModal({
      title: `给 ${targetPlayer.nickname} 茶饭`,
      content: '请输入茶饭分数',
      editable: true,
      placeholderText: '10',
      success: (res) => {
        if (res.confirm && res.content) {
          const amount = parseInt(res.content)
          if (isNaN(amount) || amount <= 0) {
            wx.showToast({
              title: '请输入有效分数',
              icon: 'none'
            })
            return
          }
          
          // 添加茶饭记录
          this.addExpenseRecord(targetPlayer.id, amount, 'tea_meal')
        }
      }
    })
  },

  // 切换记录标签
  switchRecordTab(e) {
    const type = e.currentTarget.dataset.type
    this.setData({
      showTeaMealRecords: type === 'tea_meal'
    })
    
    // 如果是茶饭记录且还没有加载过，则加载茶饭记录
    if (type === 'tea_meal' && this.data.teaMealRecords.length === 0) {
      this.getTeaMealRecords(1, false)
    }
  },

  // 获取茶饭记录
  getTeaMealRecords(page = 1, isLoadMore = false) {
    // 如果没有房间信息，不请求记录
    if (!this.data.roomInfo || !this.data.roomInfo.id) {
      console.log('房间信息不存在，跳过获取茶饭记录')
      return
    }

    // 如果正在加载记录，避免重复请求
    if (this.data.loadingRecords || (isLoadMore && this.data.loadingMore)) {
      console.log('正在加载茶饭记录中，跳过重复请求')
      return
    }

    this.setData({ loadingRecords: true })

    wx.request({
      url: `${getApp().globalData.baseUrl}/api/accounting/room-records`,
      method: 'GET',
      data: {
        room_id: this.data.roomInfo.id,
        page: page,
        page_size: 20,
        type: 'tea_meal' // 只获取茶饭记录
      },
      success: (res) => {
        if (res.data.success) {
          const newRecords = res.data.data.records || []
          
          if (isLoadMore) {
            // 加载更多时追加到现有记录
            this.setData({
              teaMealRecords: [...this.data.teaMealRecords, ...newRecords],
              hasMoreTeaMealRecords: res.data.data.has_more,
              currentTeaMealPage: page
            })
          } else {
            // 首次加载或刷新时替换记录
            this.setData({
              teaMealRecords: newRecords,
              hasMoreTeaMealRecords: res.data.data.has_more,
              currentTeaMealPage: page
            })
          }
        } else {
          console.error('获取茶饭记录失败:', res.data.message)
        }
      },
      fail: (err) => {
        console.error('获取茶饭记录请求失败:', err)
      },
      complete: () => {
        this.setData({ loadingRecords: false })
      }
    })
  },


  // 检查是否为房主
  checkIsOwner() {
    console.log('检查房主身份...')
    console.log('currentUser:', this.data.currentUser)
    console.log('roomInfo:', this.data.roomInfo)
    
    if (!this.data.currentUser || !this.data.roomInfo) {
      console.log('缺少用户信息或房间信息')
      return false
    }
    
    const isOwner = this.data.currentUser.id === this.data.roomInfo.created_by
    console.log('用户ID:', this.data.currentUser.id)
    console.log('房间创建者ID:', this.data.roomInfo.created_by)
    console.log('是否为房主:', isOwner)
    
    this.setData({ isOwner })
    
    if (isOwner) {
      console.log('初始化房主信息')
      // 从玩家列表中获取房主的最新分数
      const ownerPlayer = this.data.players.find(p => p.id === this.data.currentUser.id)
      const ownerScore = ownerPlayer ? ownerPlayer.current_score : (this.data.currentUser.current_score || 0)
      
      console.log('房主分数来源:', {
        fromPlayerList: ownerPlayer?.current_score,
        fromCurrentUser: this.data.currentUser.current_score,
        finalScore: ownerScore
      })
      
      // 初始化房主信息
      this.setData({
        ownerInfo: {
          id: this.data.currentUser.id, // 添加ID字段，用于WebSocket消息匹配
          avatar: this.data.currentUser.avatar || '',
          avatarUrl: this.processAvatarUrl(this.data.currentUser.avatar || ''),
          nickname: this.data.currentUser.nickname || '房主',
          current_score: ownerScore
        }
      })
      console.log('房主信息设置完成:', this.data.ownerInfo)
    } else {
      // 如果不是房主，清空房主信息
      this.setData({
        ownerInfo: {
          avatar: '',
          nickname: '',
          current_score: 0
        }
      })
    }
    
    return isOwner
  },

  // 更新房主信息（如果需要）
  updateOwnerInfoIfNeeded(users) {
    if (!this.data.isOwner || !this.data.currentUser) return
    
    // 从用户列表中找到房主信息
    const ownerPlayer = users.find(p => p.id === this.data.currentUser.id)
    if (ownerPlayer) {
      console.log('更新房主信息:', ownerPlayer)
      this.setData({
        ownerInfo: {
          id: ownerPlayer.id,
          avatar: ownerPlayer.avatar || '',
          nickname: ownerPlayer.nickname || '房主',
          current_score: ownerPlayer.current_score || 0
        }
      })
    }
  },

  // 保存当前房间信息到本地存储
  saveCurrentRoomInfo() {
    if (this.data.roomInfo && this.data.currentUser) {
      const RoomCache = require('../../utils/roomCache')
      
      // 使用统一的缓存管理
      RoomCache.saveRoom(this.data.roomInfo, { isNewRoom: false })
      RoomCache.saveScore(this.data.currentUser.current_score || 0)
      
      console.log('保存当前房间信息完成')
    }
  },

  // 更新当前用户分数到缓存
  updateCurrentUserScoreInCache() {
    try {
      if (this.data.currentUser && this.data.currentUser.current_score !== undefined) {
        const RoomCache = require('../../utils/roomCache')
        RoomCache.saveScore(this.data.currentUser.current_score)
        console.log('已更新缓存中的用户分数:', this.data.currentUser.current_score)
      }
    } catch (error) {
      console.error('更新用户分数到缓存失败:', error)
    }
  },

  // 通知个人中心页面更新分数
  notifyProfilePageUpdate() {
    try {
      // 获取当前页面的页面栈
      const pages = getCurrentPages()
      
      // 查找个人中心页面
      const profilePage = pages.find(page => {
        return page.route === 'pages/profile/profile'
      })
      
      if (profilePage) {
        console.log('找到个人中心页面，通知更新分数')
        // 调用个人中心页面的刷新方法
        if (typeof profilePage.refreshRoomStatus === 'function') {
          profilePage.refreshRoomStatus()
        } else if (typeof profilePage.getCurrentStatus === 'function') {
          profilePage.getCurrentStatus()
        }
      } else {
        console.log('未找到个人中心页面，分数将在下次进入时更新')
      }
    } catch (error) {
      console.error('通知个人中心页面更新失败:', error)
    }
  },


  // 处理结算通知
  handleSettlementNotification(data) {
    try {
      const remainingTime = data.remaining_time
      const message = data.message
      
      // 显示结算通知
      wx.showModal({
        title: '⏰ 自动结算提醒',
        content: message,
        showCancel: true,
        cancelText: '知道了',
        confirmText: '立即结算',
        success: (res) => {
          if (res.confirm) {
            // 用户选择立即结算
            this.triggerManualSettlement()
          }
        }
      })
      
      // 添加实时消息
      this.addRealtimeMessage(message, null)
      
      // 更新房间状态显示
      this.setData({
        settlementNotification: {
          message: message,
          remainingTime: remainingTime,
          time: new Date().toLocaleTimeString()
        }
      })
      
    } catch (error) {
      console.error('处理结算通知失败:', error)
    }
  },

  // 触发手动结算
  triggerManualSettlement() {
    wx.showLoading({ title: '正在结算...' })
    
    wx.request({
      url: `${getApp().globalData.baseUrl}/api/accounting/send-settlement-to-room`,
      method: 'POST',
      data: {
        room_id: this.data.roomInfo.id,
        user_id: this.data.currentUser.id
      },
      success: (res) => {
        if (res.data.success) {
          wx.showToast({
            title: '结算完成',
            icon: 'success'
          })
          // 刷新房间信息
          this.getRoomInfo()
        } else {
          wx.showToast({
            title: res.data.message || '结算失败',
            icon: 'none'
          })
        }
      },
      fail: (err) => {
        console.error('手动结算失败:', err)
        wx.showToast({
          title: '网络错误，请重试',
          icon: 'none'
        })
      },
      complete: () => {
        wx.hideLoading()
      }
    })
  },

  // 获取房间结算通知
  getRoomSettlementNotification() {
    if (!this.data.roomInfo || !this.data.currentUser) {
      return
    }

    // 检查是否已经有结算通知，避免重复显示
    if (this.data.settlementNotification) {
      return
    }

    wx.request({
      url: `${getApp().globalData.baseUrl}/api/accounting/room-settlement`,
      method: 'GET',
      data: {
        room_id: this.data.roomInfo.id
      },
      success: (res) => {
        if (res.data.success && res.data.data.settlement_data.length > 0) {
          // 检查是否有足够的交易数据才显示结算通知
          const settlementData = res.data.data.settlement_data
          let hasSignificantTransactions = false
          
          // 检查是否有有意义的交易（总分不为0或有多笔交易）
          settlementData.forEach(userSettlement => {
            if (userSettlement.total_score !== 0 || userSettlement.payments.length > 1) {
              hasSignificantTransactions = true
            }
          })
          
          // 只有在有足够交易数据时才显示结算通知
          if (hasSignificantTransactions) {
            const generatedAt = res.data.data.generated_at
            let notificationMessage = "🏆 房间结算完成！\n\n"
            
            settlementData.forEach(userSettlement => {
              const userName = userSettlement.user_name
              const totalScore = userSettlement.total_score
              
              if (totalScore > 0) {
                notificationMessage += `💰 ${userName} 获得 +${totalScore} 分\n`
              } else if (totalScore < 0) {
                notificationMessage += `💸 ${userName} 需要支付 ${Math.abs(totalScore)} 分\n`
              }
              
              // 添加具体支付明细
              userSettlement.payments.forEach(payment => {
                if (payment.type === 'give') {
                  notificationMessage += `   → 向 ${payment.to} 支付 ${payment.amount} 分\n`
                } else if (payment.type === 'receive') {
                  notificationMessage += `   ← 从 ${payment.from} 获得 ${payment.amount} 分\n`
                }
              })
              notificationMessage += "\n"
            })

            // 使用后端返回的结算时间
            const settlementTime = new Date(generatedAt)
            const timeString = `${settlementTime.getHours().toString().padStart(2, '0')}:${settlementTime.getMinutes().toString().padStart(2, '0')}`
            
            this.setData({
              settlementNotification: {
                message: notificationMessage,
                time: timeString,
                data: settlementData
              }
            })

            // 添加到实时消息
            this.addRealtimeMessage("房间结算已完成，请查看结算详情")
          }
        }
      },
      fail: (err) => {
        console.error('获取房间结算失败:', err)
      }
    })
  },

  // 更新tabbar状态
  updateTabbarStatus() {
    const tabbarComponent = this.selectComponent('#customTabbar')
    if (tabbarComponent && typeof tabbarComponent.setCurrentPage === 'function') {
      const RoomCache = require('../../utils/roomCache')
      const roomData = RoomCache.getRoomBasicInfo()
      tabbarComponent.updateTabbarStatus(!!roomData)
      // 设置当前页面为选中状态
      tabbarComponent.setCurrentPage()
    }
  },

  // 启动房间信息定时刷新
  startRoomRefresh() {
    // 清除之前的定时器
    this.stopRoomRefresh()
    
    // 每8秒智能刷新一次房间信息（避免频繁刷新）
    this.roomRefreshTimer = setInterval(() => {
      if (this.data.roomCode && this.data.roomInfo) {
        this.smartRefreshRoomInfo()
      }
    }, 8000)
  },

  // 停止房间信息定时刷新
  stopRoomRefresh() {
    if (this.roomRefreshTimer) {
      clearInterval(this.roomRefreshTimer)
      this.roomRefreshTimer = null
    }
  },

  // 下拉刷新
  onPullDownRefresh() {
    console.log('用户下拉刷新房间信息')
    this.refreshRoomData()
  },

  // 刷新房间数据
  refreshRoomData() {
    if (this.data.isRefreshing) {
      return // 防止重复刷新
    }

    this.setData({ 
      isRefreshing: true,
      lastRefreshTime: Date.now()
    })

    // 刷新房间信息
    this.getRoomInfo()
    
    // 刷新房间记录
    this.getRoomRecords()

    // 延迟停止刷新状态
    setTimeout(() => {
      this.setData({ isRefreshing: false })
      wx.stopPullDownRefresh()
    }, 1000)
  },

  // 检查用户是否正在交互
  checkUserInteraction() {
    // 检查是否有弹窗打开
    if (this.data.showExpenseModal || 
        this.data.showInviteModal || 
        this.data.showOwnerSettingsModal || 
        this.data.showTeaMealModal) {
      return true
    }
    
    // 检查是否正在加载
    if (this.data.loading || this.data.loadingRecords || this.data.isRefreshing) {
      return true
    }
    
    // 检查用户交互状态
    if (this.data.userIsInteracting) {
      return true
    }
    
    return false
  },

  // 智能刷新房间信息（不打断用户操作）
  smartRefreshRoomInfo() {
    // 如果用户正在交互，跳过本次刷新
    if (this.checkUserInteraction()) {
      console.log('用户正在交互，跳过定时刷新')
      return
    }

    // 如果距离上次刷新时间太短，跳过
    const now = Date.now()
    if (now - this.data.lastRefreshTime < 5000) { // 增加到5秒，避免过于频繁
      console.log('距离上次刷新时间太短，跳过定时刷新')
      return
    }

    console.log('执行智能定时刷新房间信息')
    // 只刷新房间信息，不刷新记录，避免重复添加活动记录
    this.getRoomInfo()
    this.setData({ lastRefreshTime: now })
  },


  // 确保数据同步
  ensureDataSync() {
    console.log('确保数据同步')
    // 强制刷新房间信息
    this.getRoomInfo()
    // 确保WebSocket连接
    this.initGlobalWebSocket()
  },

  // 检查WebSocket连接状态
  checkWebSocketStatus() {
    const app = getApp()
    const manager = app.getWebSocketManager()
    const status = manager.getStatus()
    const stats = manager.getConnectionStats()
    
    console.log('WebSocket状态检查:')
    console.log('- 连接状态:', status.connected)
    console.log('- 重连次数:', status.reconnectAttempts)
    console.log('- 消息处理器:', status.messageHandlers)
    console.log('- 房间订阅:', status.roomSubscriptions)
    console.log('- 实例ID:', stats.instanceId)
    console.log('- 最后连接时间:', stats.lastConnectTime ? new Date(stats.lastConnectTime).toLocaleString() : '无')
    console.log('- 最后断开时间:', stats.lastDisconnectTime ? new Date(stats.lastDisconnectTime).toLocaleString() : '无')
    
    return {
      connected: status.connected,
      hasReconnectTimer: status.hasReconnectTimer,
      messageHandlers: status.messageHandlers,
      roomSubscriptions: status.roomSubscriptions
    }
  },

  // 确保用户列表同步
  ensureUserListSync() {
    console.log('确保用户列表同步')
    const currentUser = this.data.currentUser
    if (!currentUser) {
      console.log('当前用户信息不存在，跳过用户列表同步')
      return
    }
    
    // 检查当前用户是否在玩家列表中
    const isUserInList = this.data.players.some(player => player.id === currentUser.id)
    console.log('当前用户是否在玩家列表中:', isUserInList)
    console.log('当前玩家列表:', this.data.players.map(p => ({ id: p.id, nickname: p.nickname })))
    console.log('当前用户ID:', currentUser.id)
    
    if (!isUserInList) {
      console.log('当前用户不在玩家列表中，强制刷新房间信息')
      // 延迟一点时间再刷新，确保后端数据已更新
      setTimeout(() => {
        this.getRoomInfo()
      }, 1000)
    }
  },

  // 初始化全局WebSocket（异步版本）
  async initGlobalWebSocket() {
    if (!this.data.roomInfo || !this.data.currentUser) {
      console.log('房间信息或用户信息不完整，跳过WebSocket连接')
      console.log('房间信息:', this.data.roomInfo)
      console.log('当前用户:', this.data.currentUser)
      return
    }

    // 防止重复初始化
    if (this._websocketInitializing) {
      console.log('WebSocket正在初始化中，跳过重复调用')
      return
    }
    
    const app = getApp()
    const manager = app.getWebSocketManager()
    
    // ⚠️ 关键：确保发送 connect 消息，重新建立后端映射
    // 即使用户已经连接过，重新进入房间时也需要发送 connect 消息
    // 因为可能之前的映射被清理了（比如 onHide 时误清理，或其他原因）
    console.log('========== 初始化 WebSocket 连接（房间页面） ==========')
    console.log('确保连接已建立并发送 connect 消息...')
    
    try {
      // 等待连接建立
      if (!manager.isConnected()) {
        console.log('WebSocket 未连接，等待连接建立...')
        await manager.ensureConnection()
        console.log('WebSocket 连接已建立')
      } else {
        console.log('WebSocket 已连接')
      }
      
      // 确保已发送 connect 消息（关键步骤）
      console.log('检查并确保 connect 消息已发送...')
      const connectSent = manager.ensureConnectMessageSent()
      if (connectSent) {
        console.log('✅ connect 消息已发送（或已存在）')
      } else {
        console.warn('⚠️ connect 消息发送失败，将在3秒后重试...')
        // 3秒后重试
        setTimeout(() => {
          if (manager.isConnected()) {
            console.log('重试发送 connect 消息...')
            manager.ensureConnectMessageSent()
          }
        }, 3000)
      }
    } catch (error) {
      console.error('初始化 WebSocket 连接失败:', error)
      // 即使失败，也继续尝试注册处理器
    }
    
    const roomId = this.data.roomInfo.id
    if (this._subscribedRoomIds && this._subscribedRoomIds.has(roomId)) {
      console.log(`房间 ${roomId} 已订阅，跳过重复订阅`)
      return
    }

    this._websocketInitializing = true
    
    console.log('WebSocket连接状态:', manager.getStatus())
    console.log('WebSocket连接统计:', manager.getConnectionStats())
    console.log('准备订阅房间:', roomId)
    console.log('当前用户ID:', this.data.currentUser.id)
    
    // ⚠️ 注意：connect 消息已在上面发送，这里只是检查状态
    // 为了确保可靠性，再次检查（但不要重复发送）
    if (manager.isConnected()) {
      if (manager.connectMessageSent) {
        console.log('✅ connect 消息已发送（已确认）')
      } else {
        console.warn('⚠️ 警告：连接已建立，但 connect 消息标记为未发送')
        console.warn('尝试再次发送 connect 消息...')
        manager.ensureConnectMessageSent()
      }
    }
    
    // 注册消息处理器
    this.messageHandler = (message) => {
      console.log('房间页面收到消息:', message)
      this.handleWebSocketMessage(message)
    }
    
    // 注册房间订阅
    this.roomHandler = (message) => {
      console.log('房间页面收到房间消息:', message)
      this.handleRoomWebSocketMessage(message)
    }
    
    // 注册各种消息类型的处理器
    manager.registerMessageHandler('expense_recorded', this.messageHandler)
    manager.registerMessageHandler('score_transfer', this.messageHandler)
    manager.registerMessageHandler('scoreUpdated', this.messageHandler)
    manager.registerMessageHandler('user_joined', this.messageHandler)
    manager.registerMessageHandler('user_left', this.messageHandler)
    manager.registerMessageHandler('user_rejoined', this.messageHandler)
    manager.registerMessageHandler('room_settlement', this.messageHandler)
    manager.registerMessageHandler('settlementNotification', this.messageHandler)
    
    // 确保WebSocket连接，等待连接完成
    try {
      console.log('等待WebSocket连接...')
      await manager.ensureConnection()
      console.log('WebSocket连接已建立')
    } catch (error) {
      console.error('WebSocket连接失败:', error)
      // 连接失败，尝试重连
      manager.forceReconnect()
      // 延迟重试
      setTimeout(() => {
        this.initGlobalWebSocket()
      }, 3000)
      return
    }
    
    // 订阅房间消息（会自动等待连接完成）
    console.log('准备订阅房间:', roomId, '用户ID:', this.data.currentUser.id)
    
    // 创建房间消息处理器，支持全量刷新
    const roomHandler = (message) => {
      console.log('房间消息处理器收到消息:', message.type)
      
      // 处理全量刷新消息
      if (message.type === 'room_full_refresh') {
        this.handleRoomFullRefresh(message)
        return
      }
      
      // 其他房间消息交给原有处理器
      this.handleRoomWebSocketMessage(message)
    }
    
    // 重要：发送 join_room 消息，确保后端正确处理用户加入房间
    // 即使后端在 connect 时已自动订阅，也需要发送 join_room 来更新状态
    if (manager.isConnected() && this.data.currentUser) {
      console.log('发送 join_room 消息，房间ID:', roomId, '用户ID:', this.data.currentUser.id)
      manager.sendMessage('join_room', {
        room_id: roomId,
        user_id: this.data.currentUser.id
      })
    } else {
      console.warn('WebSocket未连接或用户信息不存在，无法发送 join_room 消息')
      console.warn('连接状态:', manager.isConnected(), '用户信息:', !!this.data.currentUser)
    }
    
    const subscribeResult = await manager.subscribeRoom(roomId, roomHandler)
    console.log('房间订阅结果:', subscribeResult)
    
    if (!subscribeResult) {
      console.error('房间订阅失败')
      this._websocketInitializing = false
      // 订阅失败不影响，继续运行，依赖轮询机制
    } else {
      console.log('房间订阅成功，房间ID:', roomId)
      // 记录已订阅的房间ID
      if (!this._subscribedRoomIds) {
        this._subscribedRoomIds = new Set()
      }
      this._subscribedRoomIds.add(roomId)
      this._websocketInitializing = false
    }
  },

  // 清理全局WebSocket
  cleanupGlobalWebSocket() {
    const app = getApp()
    const roomId = this.data.roomInfo?.id
    
    // 清除初始化标记和订阅记录
    this._websocketInitializing = false
    if (roomId && this._subscribedRoomIds) {
      this._subscribedRoomIds.delete(roomId)
    }
    const manager = app.getWebSocketManager()
    
    if (roomId) {
      // 取消房间订阅
      manager.unsubscribeRoom(roomId)
    }
    
    // 注销消息处理器
    if (this.messageHandler) {
      manager.unregisterMessageHandler('expense_recorded', this.messageHandler)
      manager.unregisterMessageHandler('user_joined', this.messageHandler)
      manager.unregisterMessageHandler('user_left', this.messageHandler)
      manager.unregisterMessageHandler('room_settlement', this.messageHandler)
      manager.unregisterMessageHandler('settlementNotification', this.messageHandler)
    }
    
    console.log('已清理全局WebSocket处理器')
  },

  // 处理房间WebSocket消息
  handleRoomWebSocketMessage(message) {
    console.log('收到房间WebSocket消息:', message)
    this.handleWebSocketMessage(message)
  },
  
  // 处理房间全量刷新消息（WebSocket连接建立时触发）
  handleRoomFullRefresh(data) {
    console.log('收到房间全量刷新消息:', data)
    
    // 检查是否是当前房间
    if (this.data.roomInfo && this.data.roomInfo.id && data.room_id === this.data.roomInfo.id) {
      console.log('全量刷新当前房间数据')
      
      // 更新房间信息
      if (data.room_info) {
        this.setData({
          roomInfo: {
            ...this.data.roomInfo,
            ...data.room_info,
            current_players: data.room_info.current_players || (data.users ? data.users.length : 0),
            max_players: data.room_info.max_players
          }
        })
        console.log('房间信息已更新:', data.room_info.current_players, '/', data.room_info.max_players)
      }
      
      // 更新玩家列表（包含最新分数）
      if (data.users && Array.isArray(data.users)) {
        console.log('全量刷新玩家列表:', data.users.length, '个玩家')
        const processedPlayers = this.processPlayersAvatars(data.users)
        this.setData({ players: processedPlayers })
        
        // 更新房主信息
        this.updateOwnerInfoIfNeeded(data.users)
        
        // 更新当前用户分数
        if (this.data.currentUser) {
          const updatedUser = data.users.find(u => u.id === this.data.currentUser.id)
          if (updatedUser) {
            console.log('全量刷新：更新当前用户分数:', updatedUser.current_score)
            this.setData({
              currentUser: {
                ...this.data.currentUser,
                current_score: updatedUser.current_score
              }
            })
            // 更新缓存中的分数
            const RoomCache = require('../../utils/roomCache')
            RoomCache.saveScore(updatedUser.current_score)
          }
        }
      }
    }
  },

  // 检查并确保WebSocket连接
  ensureWebSocketConnection() {
    const app = getApp()
    const manager = app.getWebSocketManager()
    
    if (!manager.isConnected()) {
      console.log('WebSocket连接异常，尝试重新连接')
      manager.forceReconnect()
      
      // 显示连接状态提示
      wx.showToast({
        title: '正在重新连接...',
        icon: 'loading',
        duration: 2000
      })
      
      // 等待连接建立后，确保发送 connect 消息（额外保险）
      setTimeout(() => {
        if (manager.isConnected()) {
          console.log('重连成功后，检查并确保connect消息已发送')
          manager.ensureConnectMessageSent()
        }
      }, 3000) // 等待3秒，让连接有足够时间建立
      
      return false
    } else {
      // 连接正常，但检查是否已发送 connect 消息
      console.log('WebSocket已连接，检查connect消息发送状态')
      manager.ensureConnectMessageSent()
    }
    
    return true
  },

  // 重试WebSocket操作
  retryWebSocketOperation(operation, maxRetries = 3) {
    let retries = 0
    
    const attempt = () => {
      if (retries >= maxRetries) {
        console.error('WebSocket操作重试次数已达上限')
        wx.showToast({
          title: '连接失败，请检查网络',
          icon: 'none'
        })
        return false
      }
      
      if (this.ensureWebSocketConnection()) {
        operation()
        return true
      } else {
        retries++
        setTimeout(attempt, 2000)
        return false
      }
    }
    
    return attempt()
  },



  // 处理WebSocket消息
  handleWebSocketMessage(data) {
    console.log('收到WebSocket消息:', data)
    
    switch (data.type) {
      case 'user_joined':
        this.addRealtimeMessage(`${data.user?.nickname || '用户'} 进入了房间`)
        // 使用后端返回的排序用户列表更新玩家列表（与支出记录处理逻辑保持一致）
        if (data.users && Array.isArray(data.users)) {
          console.log('从用户加入消息中更新玩家列表:', data.users)
          const processedPlayers = this.processPlayersAvatars(data.users)
          // 同时更新房间信息（包括人数）
          const updateData = { players: processedPlayers }
          
          // 如果消息中包含房间信息，更新房间信息（包括人数）
          if (data.room_info) {
            updateData.roomInfo = {
              ...this.data.roomInfo,
              current_players: data.room_info.current_players,
              max_players: data.room_info.max_players,
              status: data.room_info.status
            }
            console.log('更新房间信息（人数）:', data.room_info.current_players, '/', data.room_info.max_players)
          }
          
          this.setData(updateData)
          
          // 更新房主信息
          this.updateOwnerInfoIfNeeded(data.users)
          // 更新当前用户分数（确保当前用户的分数是最新的）
          if (this.data.currentUser) {
            const updatedUser = data.users.find(u => u.id === this.data.currentUser.id)
            if (updatedUser) {
              this.setData({
                currentUser: {
                  ...this.data.currentUser,
                  current_score: updatedUser.current_score
                }
              })
              // 更新缓存中的分数
              const RoomCache = require('../../utils/roomCache')
              RoomCache.saveScore(updatedUser.current_score)
            }
          }
        } else {
          // 如果没有用户列表，刷新房间信息获取最新数据
          this.getRoomInfo()
        }
        break
        
      case 'user_left':
        this.addRealtimeMessage(`${data.user?.nickname || '用户'} 离开了房间`)
        // 使用后端返回的排序用户列表更新玩家列表（与支出记录处理逻辑保持一致）
        if (data.users && Array.isArray(data.users)) {
          console.log('从用户离开消息中更新玩家列表:', data.users)
          const processedPlayers = this.processPlayersAvatars(data.users)
          // 同时更新房间信息（包括人数）
          const updateData = { players: processedPlayers }
          
          // 如果消息中包含房间信息，更新房间信息（包括人数）
          if (data.room_info) {
            updateData.roomInfo = {
              ...this.data.roomInfo,
              current_players: data.room_info.current_players,
              max_players: data.room_info.max_players,
              status: data.room_info.status
            }
            console.log('更新房间信息（人数）:', data.room_info.current_players, '/', data.room_info.max_players)
          }
          
          this.setData(updateData)
          
          // 更新房主信息
          this.updateOwnerInfoIfNeeded(data.users)
          // 更新当前用户分数（确保当前用户的分数是最新的）
          if (this.data.currentUser) {
            const updatedUser = data.users.find(u => u.id === this.data.currentUser.id)
            if (updatedUser) {
              this.setData({
                currentUser: {
                  ...this.data.currentUser,
                  current_score: updatedUser.current_score
                }
              })
              // 更新缓存中的分数
              const RoomCache = require('../../utils/roomCache')
              RoomCache.saveScore(updatedUser.current_score)
            }
          }
        } else {
          // 如果没有用户列表，刷新房间信息获取最新数据
          this.getRoomInfo()
        }
        break
        
      case 'user_rejoined':
        this.addRealtimeMessage(`${data.user?.nickname || '用户'} 回到了房间`)
        // 使用后端返回的排序用户列表更新玩家列表（与支出记录处理逻辑保持一致）
        if (data.users && Array.isArray(data.users)) {
          console.log('从用户重新加入消息中更新玩家列表:', data.users)
          const processedPlayers = this.processPlayersAvatars(data.users)
          // 同时更新房间信息（包括人数）
          const updateData = { players: processedPlayers }
          
          // 如果消息中包含房间信息，更新房间信息（包括人数）
          if (data.room_info) {
            updateData.roomInfo = {
              ...this.data.roomInfo,
              current_players: data.room_info.current_players,
              max_players: data.room_info.max_players,
              status: data.room_info.status
            }
            console.log('更新房间信息（人数）:', data.room_info.current_players, '/', data.room_info.max_players)
          }
          
          this.setData(updateData)
          
          // 更新房主信息
          this.updateOwnerInfoIfNeeded(data.users)
          // 更新当前用户分数（确保当前用户的分数是最新的）
          if (this.data.currentUser) {
            const updatedUser = data.users.find(u => u.id === this.data.currentUser.id)
            if (updatedUser) {
              this.setData({
                currentUser: {
                  ...this.data.currentUser,
                  current_score: updatedUser.current_score
                }
              })
              // 更新缓存中的分数
              const RoomCache = require('../../utils/roomCache')
              RoomCache.saveScore(updatedUser.current_score)
            }
          }
        } else {
          // 如果没有用户列表，刷新房间信息获取最新数据
          this.getRoomInfo()
        }
        break
        
      case 'expense_recorded':
        console.log('处理支出记录消息:', data)
        console.log('支出记录消息完整内容:', JSON.stringify(data, null, 2))
        // 如果消息中包含完整的用户列表，直接更新玩家列表（与用户加入/离开处理逻辑保持一致）
        if (data.users && Array.isArray(data.users) && data.users.length > 0) {
          console.log('从支出记录消息中更新玩家列表，用户数量:', data.users.length)
          console.log('用户列表详情:', data.users.map(u => ({ id: u.id, nickname: u.nickname, score: u.current_score })))
          const processedPlayers = this.processPlayersAvatars(data.users)
          console.log('处理后的玩家列表:', processedPlayers.map(p => ({ id: p.id, nickname: p.nickname, score: p.current_score })))
          this.setData({ players: processedPlayers })
          // 更新房主信息
          this.updateOwnerInfoIfNeeded(data.users)
          // 更新当前用户分数（确保当前用户的分数是最新的）
          if (this.data.currentUser) {
            const updatedUser = data.users.find(u => u.id === this.data.currentUser.id)
            if (updatedUser) {
              console.log('更新当前用户分数:', updatedUser.current_score)
              this.setData({
                currentUser: {
                  ...this.data.currentUser,
                  current_score: updatedUser.current_score
                }
              })
              // 更新缓存中的分数
              const RoomCache = require('../../utils/roomCache')
              RoomCache.saveScore(updatedUser.current_score)
            } else {
              console.warn('当前用户不在消息的用户列表中')
            }
          }
        } else {
          console.warn('支出记录消息中没有用户列表或用户列表为空，刷新房间信息')
          // 如果没有用户列表，刷新房间信息获取最新数据
          this.getRoomInfo()
        }
        // 刷新历史记录
        this.getRoomRecords(1, false)
        break
        
      case 'score_transfer':
        // 处理积分转账消息
        console.log('处理score_transfer消息:', data)
        
        // 加强验证：确保只有当前房间的消息才会被处理
        // 如果消息中没有room_id或room_id不匹配当前房间，则忽略
        if (!data.room_id || (this.data.roomInfo && data.room_id !== this.data.roomInfo.id)) {
          console.log('忽略非当前房间的积分转账消息，当前房间ID:', this.data.roomInfo?.id, '消息房间ID:', data.room_id)
          break
        }
        
        // 确保from_user和to_user存在
        const fromUser = data.from_user || { nickname: '未知用户' }
        const toUser = data.to_user || { nickname: '未知用户' }
        
        // 积分转账应该通过历史记录显示，不需要添加实时消息
        // 刷新房间信息和历史记录以显示最新的转账记录
        console.log('刷新房间信息和记录')
        this.getRoomInfo()
        this.getRoomRecords(1, false)
        break
        
      case 'scoreUpdated':
        console.log('收到分数更新消息:', data)
        // 如果有完整的用户列表，直接更新（优先级更高，更准确）
        if (data.users && Array.isArray(data.users)) {
          console.log('从分数更新消息中更新完整玩家列表:', data.users)
          const processedPlayers = this.processPlayersAvatars(data.users)
          this.setData({ players: processedPlayers })
          // 更新房主信息
          this.updateOwnerInfoIfNeeded(data.users)
          // 更新当前用户分数
          if (this.data.currentUser) {
            const updatedUser = data.users.find(u => u.id === this.data.currentUser.id)
            if (updatedUser) {
              this.setData({
                currentUser: {
                  ...this.data.currentUser,
                  current_score: updatedUser.current_score
                }
              })
              // 更新缓存中的分数
              const RoomCache = require('../../utils/roomCache')
              RoomCache.saveScore(updatedUser.current_score)
            }
          }
        } else {
          // 如果没有完整列表，使用单用户更新方式
          this.handleScoreUpdate(data)
        }
        // 刷新历史记录以显示最新的转账记录
        this.getRoomRecords(1, false)
        break
        
      case 'room_settlement':
        console.log('收到房间结算消息:', data)
        this.setData({
          settlementNotification: {
            message: data.message,
            time: data.time,
            data: data.settlement_data
          }
        })
        this.addRealtimeMessage("房间结算已完成，请查看结算详情")
        
        // 如果消息中包含房间信息，更新房间状态
        if (data.room_info && data.room_info.status === 'finished') {
          console.log('房间已结算，更新房间状态并强制离开')
          this.setData({
            roomInfo: {
              ...this.data.roomInfo,
              status: 'finished',
              current_players: data.room_info.current_players || 0
            }
          })
          
          // 清除房间缓存
          const RoomCache = require('../../utils/roomCache')
          RoomCache.clearRoom()
          
          // 显示提示并强制离开房间
          wx.showModal({
            title: '房间已结算',
            content: '房间结算已完成，所有玩家已离开房间',
            showCancel: false,
            confirmText: '确定',
            success: () => {
              // 返回到首页
              wx.redirectTo({
                url: '/pages/index/index'
              })
            }
          })
          
          // 同时清理全局房间信息
          const app = getApp()
          app.globalData.currentRoom = null
          wx.removeStorageSync('currentRoom')
        } else {
          // 如果房间未结算，跳转到结算页面查看详情
          setTimeout(() => {
            wx.navigateTo({
              url: `/pages/room-settlement/room-settlement?room_id=${this.data.roomInfo.id}`
            })
          }, 2000) // 2秒后跳转，让用户看到结算消息
        }
        break
        
      case 'settlementNotification':
        this.handleSettlementNotification(data)
        break
        
      case 'room_status_changed':
        console.log('收到房间状态变化消息:', data)
        // 如果房间已结算，强制离开房间
        if (data.status === 'finished') {
          console.log('房间状态已变为finished，强制离开')
          this.setData({
            roomInfo: {
              ...this.data.roomInfo,
              status: 'finished',
              current_players: data.current_players || 0
            }
          })
          
          // 清除房间缓存
          const RoomCache = require('../../utils/roomCache')
          RoomCache.clearRoom()
          
          // 显示提示并强制离开房间
          wx.showModal({
            title: '房间已结算',
            content: data.message || '房间结算已完成，所有玩家已离开房间',
            showCancel: false,
            confirmText: '确定',
            success: () => {
              // 清理全局房间信息
              const app = getApp()
              app.globalData.currentRoom = null
              wx.removeStorageSync('currentRoom')
              // 返回到首页
              wx.redirectTo({
                url: '/pages/index/index'
              })
            }
          })
        }
        break
        
      case 'tea_meal_settings':
        console.log('收到茶饭设置消息:', data)
        // 添加茶饭设置消息到实时消息列表
        this.addRealtimeMessage(data.message, new Date().toISOString())
        break
        
      case 'tea_meal_deduction':
        console.log('收到茶饭费扣除消息:', data)
        // 添加茶饭费扣除消息到实时消息列表
        this.addRealtimeMessage(data.message, new Date().toISOString())
        // 刷新房间信息以更新分数
        this.getRoomInfo()
        break
        
      default:
        console.log('未知的WebSocket消息类型:', data.type)
    }
  },

  // 判断是否需要更新房主信息
  shouldUpdateOwnerInfo(serverUser) {
    const now = Date.now()
    
    // 如果本地房主信息不存在，需要更新
    if (!this.data.ownerInfo || !this.data.ownerInfo.id) {
      console.log('本地房主信息不存在，需要更新')
      return true
    }
    
    // 如果服务器用户信息不存在，跳过更新
    if (!serverUser || serverUser.current_score === undefined) {
      console.log('服务器用户信息不完整，跳过更新')
      return false
    }
    
    // 如果房主信息最近更新过（5秒内），优先保持本地数据
    if (this.data.ownerInfoLastUpdate && (now - this.data.ownerInfoLastUpdate) < 5000) {
      console.log('房主信息最近更新过，保持本地数据')
      return false
    }
    
    // 如果本地分数为0且服务器分数不为0，需要更新
    if (this.data.ownerInfo.current_score === 0 && serverUser.current_score !== 0) {
      console.log('本地分数为0，服务器分数不为0，需要更新')
      return true
    }
    
    // 如果服务器分数明显大于本地分数（可能是新的支出操作），需要更新
    if (serverUser.current_score > this.data.ownerInfo.current_score) {
      console.log('服务器分数大于本地分数，需要更新')
      return true
    }
    
    // 如果服务器分数明显小于本地分数（可能是新的收入操作），需要更新
    if (serverUser.current_score < this.data.ownerInfo.current_score) {
      console.log('服务器分数小于本地分数，需要更新')
      return true
    }
    
    // 其他情况保持本地数据
    console.log('保持本地房主信息，不更新')
    return false
  },

  // 更新房主分数
  updateOwnerScore(newScore) {
    console.log('更新房主分数到:', newScore)
    const now = Date.now()
    this.setData({
      ownerInfo: {
        ...this.data.ownerInfo,
        id: this.data.currentUser.id,
        current_score: newScore
      },
      currentUser: {
        ...this.data.currentUser,
        current_score: newScore
      },
      ownerInfoLastUpdate: now
    })
    
    // 更新缓存中的分数
    const RoomCache = require('../../utils/roomCache')
    RoomCache.saveScore(newScore)
    
    console.log('房主分数已更新:', {
      ownerInfo: this.data.ownerInfo,
      currentUser: this.data.currentUser,
      updateTime: now
    })
  },

  // 强制刷新房主信息
  forceRefreshOwnerInfo() {
    if (!this.data.isOwner || !this.data.currentUser || !this.data.players) {
      console.log('强制刷新房主信息条件不满足')
      return
    }
    
    console.log('强制刷新房主信息')
    const ownerPlayer = this.data.players.find(p => p.id === this.data.currentUser.id)
    if (ownerPlayer) {
      const newOwnerInfo = {
        id: this.data.currentUser.id,
        avatar: ownerPlayer.avatar || this.data.ownerInfo.avatar || '',
        avatarUrl: this.processAvatarUrl(ownerPlayer.avatar || this.data.ownerInfo.avatar || ''),
        nickname: ownerPlayer.nickname || this.data.ownerInfo.nickname || '房主',
        current_score: ownerPlayer.current_score || 0
      }
      
      this.setData({
        ownerInfo: newOwnerInfo,
        currentUser: {
          ...this.data.currentUser,
          current_score: ownerPlayer.current_score
        }
      })
      
      console.log('房主信息已强制刷新:', newOwnerInfo)
    }
  },

  // 处理分数更新
  handleScoreUpdate(data) {
    try {
      console.log('处理分数更新:', data)
      
      // 更新玩家列表中的分数
      const players = this.data.players.map(player => {
        if (player.id === data.user_id) {
          return {
            ...player,
            current_score: data.new_score
          }
        }
        return player
      })
      
      // 更新当前用户分数（如果是当前用户）
      if (this.data.currentUser && this.data.currentUser.id === data.user_id) {
        this.setData({
          currentUser: {
            ...this.data.currentUser,
            current_score: data.new_score
          }
        })
        
        // 更新缓存中的分数
        const RoomCache = require('../../utils/roomCache')
        RoomCache.saveScore(data.new_score)
        
        console.log('已更新当前用户分数:', data.new_score)
      }
      
      // 更新房主信息（如果是房主）
      if (this.data.isOwner && this.data.currentUser && this.data.currentUser.id === data.user_id) {
        console.log('更新房主分数:', data.new_score)
        this.setData({
          ownerInfo: {
            ...this.data.ownerInfo,
            id: this.data.currentUser.id,
            current_score: data.new_score
          }
        })
        console.log('房主分数已更新:', data.new_score)
      }
      
      // 更新玩家列表
      this.setData({ players })
      
      // 不再添加分数更新的实时消息，避免重复显示
      // 分数更新应该通过历史记录显示，而不是实时消息
      
    } catch (error) {
      console.error('处理分数更新失败:', error)
    }
  },

  // 刷新房间信息
  refreshRoomInfo() {
    console.log('开始刷新房间信息')
    if (!this.data.roomInfo || !this.data.roomInfo.id) {
      console.log('房间信息不完整，跳过刷新')
      return
    }

    const app = getApp()
    wx.request({
      url: `${app.globalData.baseUrl}/api/room/get-by-code`,
      method: 'GET',
      data: { room_code: this.data.roomInfo.room_code },
      success: (res) => {
        if (res.data.success && res.data.data) {
          const roomData = res.data.data
          console.log('房间信息刷新成功:', roomData)
          
          // 更新房间基本信息
          this.setData({
            roomInfo: {
              ...this.data.roomInfo,
              current_players: roomData.current_players,
              status: roomData.status
            }
          })
          
          // 更新玩家列表
          if (roomData.users && Array.isArray(roomData.users)) {
            console.log('更新玩家列表:', roomData.users)
            this.setData({ players: roomData.users })
            this.updateOwnerInfoIfNeeded(roomData.users)
          }
          
          console.log('房间信息已刷新')
        } else {
          console.log('房间信息刷新失败:', res.data)
        }
      },
      fail: (err) => {
        console.error('刷新房间信息请求失败:', err)
      }
    })
  }

})
